Celestin Apprentice 2/Apprentice-Release2.iso/Source Code/Think Class Libraries/Item Class/Item sources/CItem.c

C/C++ Source or Header | 1994-11-30 | 5.4 KB | 361 lines | [TEXT/KAHL]

/*
 * File:        CItem.c
 * Created:        7/25/93
 * Desc:        An item that can be displayed in an ItemTable Pane.
 *                The item keeps a reference to its parent (the root
 *                objects parent is NULL), and a reference to each
 *                of its children (subItems).
 *
 * Superclass:    CObject.
 * Uses:        <NONE>.
 * Original Author:    Atul Barve
 * Modifications:    W. Wesley Monroe
 *
 * Copyright © 1993 Animas Software Production. All rights reserved.
 */

#include    <string.h>

#include    "CItem.h"

void    CItem::IItem(void)
{
    fSubItems = 0;
    fExpanded = 0;
    fLevel = 0;
    fText = 0;
    fParent = 0L;
}

void    CItem::INewRootItem(short canExpand, short iconID, short expanded,
                           StringPtr text)
{
    short    sLen;
    char    *txt;

    fCanExpand = canExpand;
    fIconID    = iconID;
    fExpanded = expanded;

    sLen = text[0];
    ASSERT(sLen);

    txt = (char *) NewPtr(sLen + 1);
    fText = txt;
    memcpy(txt, text, sLen + 1);

    fParent = 0L;
    fSubItems = 0L;
    fLevel = 0;
}

void    CItem::Dispose(void)
{
    if(fSubItems)
        fSubItems->DisposeAll();

    ForgetObject(fSubItems);
    ForgetPtr(fText);
}


short    CItem::GetIconID(void)
{
    return fIconID;
}

void    CItem::SetIconID(short id)
{
    fIconID = id;
}

void    CItem::SetParent(CItem *parent)
{
    fParent = parent;
}

CItem    *CItem::GetParent(void)
{
    return fParent;
}

Boolean CItem::CanAccept(CList *selectedItems)
{
    return fCanExpand;
}

void CItem::RemoveSubItem(CItem *child)
{

    ASSERT(fSubItems);

    fSubItems->Remove(child);

    if(fSubItems->GetNumItems() < 1) {

        SetCanExpand(FALSE);
    }
}

void    CItem::GetDisplayText(char *text)
{
    if(fText == 0)
        text[0] = 0;
    else
        memcpy(text,fText,fText[0] + 1);
}

void    CItem::SetDisplayText(char *text)
{

    if(fText)
        ForgetPtr(fText);
    fText = (char *) NewPtr(text[0] + 1);
    memcpy(fText,text,text[0]+1);
}

void    CItem::AppendSubItem(CItem *item)
{
    if(fSubItems == 0) {
        fSubItems = new CList;
        fSubItems->IList();
    }

    fSubItems->Append(item);
    item->SetLevel(GetLevel() + 1);
}

void    CItem::GraftSubItem(CItem *item)
{
    if(fSubItems == 0) {
        fSubItems = new CList;
        fSubItems->IList();
    }

    fSubItems->Append(item);
    item->SetLevel(GetLevel() + 1);
}

void    CItem::SetNthSubItem(CItem *item, short n)
{
    if(fSubItems == 0) {
        fSubItems = new CList;
        fSubItems->IList();
    }
    item->SetLevel(GetLevel() + 1);

    if(n == 0)
        fSubItems->Prepend(item);
    else if(n > fSubItems->GetNumItems())
        fSubItems->Append(item);
    else
        fSubItems->InsertAt(item,n);
}

short    CItem::GetLevel(void)
{
    return fLevel;
}

void    CItem::SetLevel(short level)
{
    short    i,n;
    CItem    *sub;

    if(fSubItems) {
        n = fSubItems->GetNumItems();
        for(i=1;i<=n;i++) {
            sub = (CItem*) fSubItems->NthItem(i);
            sub->SetLevel(level+1);
        }
    }
    fLevel = level;
}

CItem    *CItem::GetNthSubItem(short n)
{
    if(fSubItems)
        return (CItem*)fSubItems->NthItem(n);
    return 0;
}


short    CItem::GetNumSubItems(void)
{
    if(fSubItems)
        return fSubItems->GetNumItems();
    return 0;
}

short    CItem::GetExpanded(void)
{
    return fExpanded;
}

void    CItem::SetExpanded(short flag)
{
    fExpanded = flag;
}

void    CItem::SetCloseIconID(short id)
{
    fCloseIconID = id;
}


void    CItem::SetOpenIconID(short id)
{
    fOpenIconID = id;
}


void    CItem::SetInterimIconID(short id)
{
    fInterimIconID = id;

}



short    CItem::GetCloseIconID(void)
{
    return fCloseIconID;
}


short    CItem::GetOpenIconID(void)
{
    return fOpenIconID;
}


short    CItem::GetInterimIconID(void)
{
    return fInterimIconID;
}

void    CItem::SetCanExpand(short flag)
{
    fCanExpand = flag;

}

short    CItem::GetCanExpand(void)
{
    return fCanExpand;
}

void CItem::ReAllocSubItems(void)
{
    fSubItems = new CList;
    fSubItems->IList();
}

CItem *CItem::CopyItem(Boolean copySubItems)
{
    CItem *anItem;

    anItem = (CItem *) this->Copy();

    /*
     * if copySubItems is true, recuresively duplicate
     * the child objects.  Otherwise, lop off the subItems
     * by ReAllocing the SubItems to create an empty
     * subItems list.
     */

    if(copySubItems) {

        long i, n;

        n = GetNumSubItems();

        for(i = 1; i <= n; i++) {

            CItem *sub;

            sub = GetNthSubItem(i);
            ASSERT(sub);
            sub->SetParent(anItem);
            sub->CopyItem(copySubItems);
        }
    } else
        anItem->ReAllocSubItems();

    return anItem;
}

/*
 * GetExtraItemData()
 *
 *    Subclasses can override this method to read in data
 *    specific to the New Kind of Item.
 *  NOTE:    This method should advance the handle past the
 *            extra data that it reads.
 */

void CItem::GetExtraItemData(Ptr *data)
{

}

void CItem::BuildExtraItemData(Handle data)
{

}

/*
 * BuildRes()
 *
 *    Recursively build the items tree into data....
 */

void CItem::BuildRes(Handle data)
{
    char    *text;

    long    i, n;
    short    tmpS, numItems;
    short    sLen;
    char    dummy;

        // Copy the text into a new Even Packed Pascal String.
    sLen = fText[0];
    text = NewPtr(sLen + 1);
    memcpy(text, fText, sLen + 1);

        // stuff all the data into the Handle
    tmpS = fCanExpand;
    PtrAndHand(&tmpS, data, sizeof(short));
    tmpS = fExpanded;
    PtrAndHand(&tmpS, data, sizeof(short));
    tmpS = fIconID;
    PtrAndHand(&tmpS, data, sizeof(short));
    tmpS = 0;
    PtrAndHand(&tmpS, data, sizeof(short));
    tmpS = 0;
    PtrAndHand(&tmpS, data, sizeof(short));
        PtrAndHand(text, data, sLen + 1);

        // padd an even string...
    if(sLen % 2 == 0)
        PtrAndHand(&dummy, data, sizeof(char));

    if(fSubItems)
        numItems = n = fSubItems->GetNumItems();
    else
        numItems = n = 0;

    BuildExtraItemData(data);

    PtrAndHand(&numItems, data, sizeof(short));

    for(i = 1; i <= n; i++) {
        CItem *anItem;

        anItem = (CItem *) fSubItems->NthItem(i);
        anItem->BuildRes(data);
    }
}